<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Fozzy.System</name>
    </assembly>
    <members>
        <member name="T:Fozzy.Concept`2">
            <summary>
            Attention cette classe est générée automatiquement par un outil T4
            Ne pas la modifier avec un éditeur car les modification seraient écrasées à la prochaine regénération.
            Copyright @Homethic 2013
            </summary>
            <summary>
            Main functional Object.
            Every inheritance line goes ultimately hits the Concept.
            </summary>
        </member>
        <member name="T:Fozzy.OneN`2">
            <summary>
            Deepest object.
            Represents the original 1-N relation between :
            - a "one" object
            - an "n" object
            </summary>
        </member>
        <member name="M:Fozzy.OneN`2.Get``1(System.String)">
            <summary>
            Attention à surcharger cette méthode si on veut éviter le null
            </summary>
            <typeparam name="instance"></typeparam>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:Fozzy.OneN`2.Set(System.Int32)">
            <summary>
            Le Concept sélectionne dans les Parts, et non dans les Relations 
            </summary>
            <param name="pos"></param>
        </member>
        <member name="M:Fozzy.OneN`2.Add(System.Collections.Generic.IEnumerable{Fozzy._Element})">
            <summary>
            Je me charge de l'upgrade en Type n : C'est mon job de Concept
            </summary>
            <param name="elements"></param>
        </member>
        <member name="M:Fozzy.OneN`2.Add(Fozzy._Element)">
            <summary>
            Visible de l'extérieur pour Upgrade
            </summary>
            <param name="element"></param>
        </member>
        <member name="T:Fozzy.IElement">
            <summary>
            On définit la méthode naturelle Relate pour l'Interface IRelation
            </summary>
        </member>
        <member name="T:Fozzy.IIdentifier">
            <summary>
            On définit la méthode naturelle Relate pour l'Interface IRelation
            </summary>
        </member>
        <member name="M:Fozzy.Concept`2.#ctor">
            <summary> Exposes various public constructors conveying 
            the necessary parameters to instantiate a Concept 
            in different circumstances. 
            </summary>
        </member>
        <member name="M:Fozzy.Concept`2.#ctor(Fozzy._Element)">
            <summary>
            Ici cas particulier de consructeur : L'Element contient potentiellement un Name, un Identifiant, une Value ...
            </summary>
            <param name="element"></param>
        </member>
        <member name="M:Fozzy.Concept`2.#ctor(Fozzy.Name,Fozzy.Directory)">
            <summary>
            Attention ici le Name est avec Extension
            </summary>
            <param name="file"></param>
            <param name="dir"></param>
        </member>
        <member name="M:Fozzy.Concept`2.Dispose">
            <summary> Exposes the different Relations of 
            this instance of Concept to other Concepts.</summary>
        </member>
        <member name="M:Fozzy.Concept`2.Be(Fozzy.IConcept,System.Object)">
            <summary>
            Attention, ce Be ici devient complètement Functional.
            Du coup l'implémentation par défaut au niveau du Virtual est très probablement mauvaise ...
            </summary>
            <param name="target"></param>
            <param name="selection"></param>
            <returns></returns>
        </member>
        <member name="M:Fozzy.Concept`2.Contains(Fozzy.IConcept)">
            <summary>
            En standard False 
            </summary>
            <param name="target"></param>
            <returns></returns>
        </member>
        <member name="M:Fozzy.Concept`2.Initialise">
            <summary>
            Cette méthode est lançée au démarrage de l'Objet, pour le rendre prêt à l'utilisation
            Les étapes sont toujours exécutées dans le même ordre : Set / Start / Live / Prepare / Execute / Finish
            La surcharge des différentes étapes est possible (public virtual void)
            </summary>
        </member>
        <member name="M:Fozzy.Concept`2.Start">
            Le Start met le Enabled
        </member>
        <member name="M:Fozzy.Concept`2.Dispose(System.Boolean)">
            <summary>
            Child classes can override this method to perform 
            clean-up logic, such as removing event handlers.
            If <paramref name="disposeManagedResources"/> equals <c>True</c>, all managed resources should be disposed.
            Both managed and unmanaged resources should only get disposed if this method is executed for the first time.
            </summary>
            <param name="disposeManagedResources">Indicates whether managed resources should be disposed.</param>
        </member>
        <member name="M:Fozzy.Concept`2.Properties">
            <summary>
            Attention : Ici on accède aux Propriétés de la base.Value, et non de la Value
            </summary>
            <returns></returns>
        </member>
        <member name="M:Fozzy.Concept`2.Re_Name">
            <summary>
            Quand un Concept a été spécifiquement baptisé par une String,
            On doit tenter un Parse
            </summary>
        </member>
        <member name="M:Fozzy.Concept`2.Default_Parts">
            <summary>
            Si le Type a des types dérivés on les Instancie dans les Parts
            Est-ce à faire systématiquement ?
            </summary>
        </member>
        <member name="M:Fozzy.Concept`2.Subscribe(Fozzy.IConcept)">
            <summary>
            Quand je subscribe à une source, je reçois ses Events : Property à ce level, mais Instance en plus, au niveau Concept
            </summary>
            <param name="source"></param>
        </member>
        <member name="M:Fozzy.Concept`2.Re_Source">
            <summary>
            On alimente les Properties de la Value 
            </summary>
        </member>
        <member name="M:Fozzy.Concept`2.Change_Occured(System.Object,Fozzy.Arguments)">
            <summary>
            Réception d'un Event
            </summary>
            <param name="sender"></param>
            <param name="args"></param>
        </member>
        <member name="M:Fozzy.Concept`2.Add(Fozzy._Element)">
            <summary>
            Utilisé pour Etendre l'élément
            </summary>
            <param name="element"></param>
        </member>
        <member name="M:Fozzy.Concept`2.Execute">
            <summary>
            A la fin de l'Init d'un Object, on le Relate
            On exécute la méthode Relate de toutes ses propriétés qui affichent IRelation
            La méthode est virtual, car les Objects la surchargent. pour leurs Instances
            
            </summary>
        </member>
        <member name="M:Fozzy.Concept`2.Relate(Fozzy.IName,System.Int32)">
            <summary>
            Relative Relation = Relation related to the position of the Part in the Collection
            When a Part is added to a Concept, a Relate method is triggered to give a chance to the Part of doing something with its owner.
            The i of the relative position in the Parts ENumeration is also given as a Parameter
            </summary>
            <param name="owner"></param>
        </member>
        <member name="M:Fozzy.Concept`2.Relate(Fozzy.IConcept)">
            <summary>
            Absolute Relation : Based on the properties of the Concept received as parameter
            </summary>
            <param name="part"></param>
        </member>
        <member name="M:Fozzy.Concept`2.Relate(Fozzy.IRelation)">
            <summary>
            Ready-made Relation, to be added without further discussion
            </summary>
            <param name="relation"></param>
        </member>
        <member name="M:Fozzy.Concept`2.Re_Set(System.String)">
            <summary>
            Agnostic Re_Set of a Property, if this Property exists on the Concept.
            </summary>
            <param name="name"></param>
        </member>
        <member name="M:Fozzy.Concept`2.Load">
            <summary>
            En Load, le File me transmet des Elements : C'est à dire agnostique par rapport au Type
            Le Type est toutefois descendu, afin de faire une sélection dans les Elements, sur la base du Name/Alias du Type
            Je ne sais pas a priori si le File contient des Parts, des Relations ...
            </summary>
        </member>
        <member name="M:Fozzy.Concept`2.Save">
            <summary>
            Quand on Save, on Save les Parts et les Relations dans le même File
            </summary>
        </member>
        <member name="M:Fozzy.Concept`2.Save(System.String)">
            <summary>
            J'aime pas l'idée qu'on reçoit la chaine complète, 
            Je répartis donc les éléments de la chaine sur les propriétés concernées
            </summary>
            <param name="fullName"></param>
        </member>
        <member name="P:Fozzy.Concept`2.Value">
            <summary>
            Value is stored in the Concept. It is writable 
            </summary>
        </member>
        <member name="P:Fozzy.Concept`2.Prefix">
            <summary>
            Templates used to extend the name of the Parts when used in the context of this Concept
            They are pushed into the Name of the Part during Prepare of the Concept
            </summary>
        </member>
        <member name="P:Fozzy.Concept`2.Element">
            <summary>
            The Element is the Transitional objects that will allow to pass Meaning
            between for example the Value and the Parts.
            The whole point is that all Concepts can understand its meaning, because it is stored as Serialized 
            </summary>
        </member>
        <member name="T:Fozzy.Enumeration`1">
            <summary>
            Le string supplémentaire est le séparateur
            </summary>
        </member>
        <member name="M:Fozzy.Enumeration`1.Execute(Fozzy.IActionable)">
            <summary>
            Executer un Tuples, c'est exécuter systématiquement ses Instances, dans la mesure où les Instances sont IExecutable
            </summary>
        </member>
        <member name="M:Fozzy.Enumeration`1.Parse(System.String)">
            <summary>
            A surcharger pour rentrer une String dans une Enumeration au constructeur
            </summary>
            <param name="filter"></param>
        </member>
        <member name="M:Fozzy._Element.#ctor">
            <summary>
            Base direct
            </summary>
        </member>
        <member name="M:Fozzy._Element.#ctor(Fozzy.IName,Fozzy.IName)">
            <summary>
            Transit This
            </summary>
            <param name="e1"></param>
            <param name="e2"></param>
        </member>
        <member name="M:Fozzy._Element.#ctor(Fozzy._Element)">
            <summary>
            Toujours revenir sur ces Constructeurs
            </summary>
            <param name="element"></param>
        </member>
        <member name="M:Fozzy._Element.Get(Fozzy.XAttribute)">
            <summary>
            Cette méthode renvoit les Noeuds locaux définis par le nom attribute
            La difficulté c'est que je veux gérer le Pluriel et le Singulier : nodeStyles / nodeStyle
            </summary>
            <param name="attribute"></param>
            <returns></returns>
        </member>
        <member name="M:Fozzy._Element.Add(Fozzy.Name)">
            <summary>
            Je reçois certains attributs sous forme de Name
            en provenance de la DataRow (Voir le Element de Concept)
            </summary>
            <param name="attribute"></param>
        </member>
        <member name="M:Fozzy._Element.Add(Fozzy._Element)">
            <summary>
            Ici la complexité c'est que l'on ne veut pas que l'ajout soit imbriqué ...
            mais au contraire que les différents composantes de l'element soit cote à cote
            </summary>
            <param name="element"></param>
        </member>
        <member name="M:Fozzy._Element.Set``1(Fozzy.Many{``0})">
            <summary>
            Chaque Propriété fonctionnelle est sérialisée comme un XAttribute de l'Element
            </summary>
            <param name="propName"></param>
            <param name="propValue"></param>
        </member>
        <member name="M:Fozzy._Element.Stamp">
            <summary>
            Le System.Type reçu ici est une tentative déséspérée de retrouver de l'information dans l'Element
            Dans le cas où le name ne ramène rien
            Et ensuite, désépérée de désepérée, on recherhce le type.Name en lower caps
            </summary>
            <param name="name"></param>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="T:Fozzy.Name">
            <summary>
            A Name is the most basic Semantic Object, made of at least 1 string.
            A Name represents the naming convention of a Semantic Object. 
            </summary>
        </member>
        <member name="T:Fozzy.Many`1">
            <summary>
            Le string supplémentaire est le séparateur
            </summary>
        </member>
        <member name="M:Fozzy.Many`1.Set(System.Int32)">
            <summary>
            Plein de cas d'erreurs fonctionnelles
            </summary>
            <param name="pos"></param>
        </member>
        <member name="M:Fozzy.Many`1.Get(System.Int32,Fozzy.Name)">
            <summary>
            Get de 1er niveau
            </summary>
            <param name="i"></param>
            <param name="search"></param>
            <returns></returns>
        </member>
        <member name="M:Fozzy.Many`1.Send(Fozzy.method,System.Object)">
            <summary>
            Cas normal d'exécution de méthode
            Parameter spécifique à la méthode
            Verb Exécuté en état Normal
            </summary>
            <param name="method"></param>
            <param name="parameter"></param>
        </member>
        <member name="F:Fozzy.Name.Limit">
            <summary>
            Dans le cas où on découpe l'objet pour le sortir en texte, on choisit arbitrairement la taille du découpage
            </summary>
        </member>
        <member name="M:Fozzy.Name.#ctor">
            <summary>
            Generic construct. Use when no additional parameters are required for the Object.
            Used by the system as default constructor.
            Required by Serialization
            </summary>
        </member>
        <member name="M:Fozzy.Name.#ctor(System.Xml.XmlNode)">
            <summary>
            On tente par défaut le "Name" pour un XmlNode ...
            </summary>
            <param name="node"></param>
        </member>
        <member name="M:Fozzy.Name.Set(System.Object)">
            <summary>
            C'est un Set particulier qui commence par un ReSet
            </summary>
            <param name="value"></param>
        </member>
        <member name="M:Fozzy.Name.Set(System.String)">
            <summary>
            When affecting the List of string,
            A OnPropertyChanged is issued.
            </summary>
            <param name="addition"></param>
        </member>
        <member name="M:Fozzy.Name.Split(System.Char)">
            <summary>
            C'est un peu zarbi : On doit savoir que quand on split, on split le First_Name
            </summary>
            <param name="splitter"></param>
        </member>
        <member name="M:Fozzy.Name.Change_Occured(System.Object,Fozzy.Arguments)">
            <summary>
            Réception d'un Event
            </summary>
            <param name="sender"></param>
            <param name="args"></param>
        </member>
        <member name="P:Fozzy.Name.Chunks">
            <summary>
            Découpage du Name en tronçons de taille Limit
            </summary>
        </member>
        <member name="M:Fozzy.File.#ctor">
            <summary>
            Si je reçois une String     : c'est un Fullname avec Dir et Extension
            Si je reçois 2   Strings    : c'est un name avec Extension (sans Dir)
            Si je reçois 3   Strings    : c'est un Dir, un name , une Extension
            </summary>
        </member>
        <member name="M:Fozzy.File.#ctor(Fozzy.Directory,Fozzy.Name)">
            <summary>
            Fallback systématique
            </summary>
            <param name="dir"></param>
            <param name="name"></param>
            <param name="extension"></param>
        </member>
        <member name="M:Fozzy.File.Prepare">
            <summary>
            Si le File existe au moment où je l'instancie, je le charge
            </summary>
        </member>
        <member name="M:Fozzy.File.Load">
            <summary>
            On considère que les Sources sont les ELements déjà présents dans le Fichier physique
            </summary>
        </member>
        <member name="M:Fozzy.File.Save">
            <summary>
            On considère que les Instances sont les nouveautés arrivées par des Add (notamment celui de l'ouverture)
            et qu'il faut réenvoyer dans le fichier physique
            </summary>
        </member>
        <member name="M:Fozzy.File.Execute(Fozzy.method)">
            <summary>
            La particularité c'est l'instantiation 
            puis la Libération
            </summary>
            <param name="method"></param>
        </member>
        <member name="T:Fozzy._Object`2">
            <summary>
            La Faiblesse de cet objet c'est de tenter d'initialiser des e1 e2 sans rien connaître à leur propos,
            et notamment le fait d'exposer un constructeur sans paramètres
            </summary>
        </member>
        <member name="M:Fozzy._Object`2.Set(`0)">
            <summary>
            Le problème ici c'est que si on Set e1, on perd e2 et vice versa ....
            </summary>
            <param name="value"></param>
        </member>
        <!-- Commentaire XML incorrect ignoré pour le membre "T:Fozzy.Relative" -->
        <member name="T:Fozzy.Sentence">
            <summary>
            A Sentence is a Semantic Object matching the grammatical Sentence { Subject, Verb, Complement(s) } in any given Language 
            </summary>
        </member>
        <member name="M:Fozzy.CBoolean.#ctor(System.String,System.String,Fozzy.verb,Fozzy.IConcept)">
            <summary>
            Je Parse et conserve les Properties reçues dans la châine properties "Parents or Siblings or Partners"
            Mon objectif c'est d'en faire des Compléments
            </summary>
            <param name="name"></param>
            <param name="parser"></param>
            <param name="verb"></param>
            <param name="concept"></param>
        </member>
        <member name="T:Fozzy.Component">
            <summary>
            Cet Attribut, indique que la Source est à trouver dans l'Element
            </summary>
        </member>
        <member name="M:Fozzy.Alias.#ctor(System.Type)">
            <summary>
            Generic construct. Use when no additional parameters are required for the Object.
            Used by the system as default constructor.
            Required by Serialization
            </summary>
        </member>
        <member name="M:Fozzy.Template.#ctor">
            <summary>
            Par défaut, on construit un Template avec Position0
            </summary>
        </member>
        <member name="T:Fozzy.Relation">
            <summary>
            A Relation is a Semantic Object that describes a relation between two Semantic Objects.
            It also contains all the pairs of IConcept that represent this Relation.
            </summary>
            <typeparam name="concept">The Concept is a type parameter that represents the target in the relation.</typeparam>
        </member>
        <member name="T:Fozzy.Relation`1">
            <summary>
            A Relation is a Semantic Object that describes a relation between two Semantic Objects.
            It also contains all the pairs of IConcept that represent this Relation.
            </summary>
            <typeparam name="concept">The Concept is a type parameter that represents the target in the relation.</typeparam>
        </member>
        <member name="T:Fozzy.IRelation">
            <summary>
            On définit la méthode naturelle Relate pour l'Interface IRelation
            </summary>
        </member>
        <member name="P:Fozzy.Relation`1.Source">
            <summary>
            La Source est l'élément d'origine de la Relation
            </summary>
        </member>
        <member name="M:Fozzy.Relation.Add(Fozzy.IName)">
            <summary>
            Quand on ajoute on TimeStamp
            </summary>
            <param name="relation"></param>
        </member>
        <member name="T:Fozzy.Settings">
            <summary>
            Concept built to manage the FamilyShow Resources conveyed by the ResourceManager
            </summary>
        </member>
        <member name="T:Fozzy.Filter`1">
            <summary>
            A Selection is specific, in the sens that it manipulates a criteria
            applied on a specific property of a IConcept
            </summary>
            <typeparam name="result"></typeparam>
            <typeparam name="criteria"></typeparam>
        </member>
        <!-- Commentaire XML incorrect ignoré pour le membre "T:Fozzy.Skill`2" -->
        <member name="M:Fozzy.Skill`2.#ctor">
            <summary>
            A Skill can be constructed with no parameter.
            </summary>
        </member>
        <member name="M:Fozzy.Filter`1.Match(`0,System.Object)">
            <summary>
            The Manner parameter is an Enumeration to farther switch the Match
            </summary>
            <param name="concept"></param>
            <param name="manner"></param>
            <returns></returns>
        </member>
        <member name="T:Fozzy.Selection`1">
            <summary>
            A Selection is specific, in the sens that it manipulates a criteria
            applied on a specific property of a IConcept
            </summary>
            <typeparam name="result"></typeparam>
            <typeparam name="criteria"></typeparam>
        </member>
        <!-- Commentaire XML incorrect ignoré pour le membre "T:Fozzy.Skill`1" -->
        <member name="T:Fozzy.Relative`1">
            <summary>
            Argh : Ici ya un prob : Le Range est démultiplié dans les Parts
            </summary>
        </member>
        <member name="T:Fozzy.XFile">
            <summary>
            Converts a GEDCOM file to an XML file.
            </summary>
        </member>
        <member name="M:Fozzy.XFile.#ctor(System.String)">
            <summary>
            Un XFile a des capacités Read Write
            </summary>
            <param name="fullname"></param>
        </member>
        <member name="M:Fozzy.Exhaustive`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            On peut aussi simplement déclarer les Possibles, sans spécifier de Value
            qui viendra plus tard.
            </summary>
            <param name="possibles"></param>
        </member>
        <member name="M:Fozzy.Exhaustive`1.Prepare">
            <summary>
            C'est une classe où il faut impérativement instancier toutes les Options possibles
            </summary>
        </member>
        <member name="M:Fozzy.Exhaustive`1.Locate(`0)">
            <summary>
            Quand on prepare un Exhaustive, on repère la Position de la Value dans la liste des Possibles
            </summary>
        </member>
        <member name="M:Fozzy.Boolean.Add">
            <summary>
            Je vois mal la règle qui expliquerait que false vient avant true
            </summary>
        </member>
        <member name="T:Fozzy.Capacity">
            <summary>
            2 bools : 
            - La capacity "Disposable"
            - La propriété "Disposed"
            Attention : On ne peut pas utiliser l'Objet Pair, sinon on boucle sur _System
            </summary>
        </member>
        <member name="M:Fozzy.Capacity.#ctor">
            <summary>
            En spontané, la "able" est true, sinon on ne mettrait pas la Capacity sur l'objet
            </summary>
        </member>
        <member name="T:Fozzy.IActionable">
            <summary>
            This interface define What could be the target of an action
            </summary>
        </member>
        <member name="T:Fozzy.Trilean">
            <summary>
            Le prob, c'est que la Pair me donne 4 options, mais je n'en ai besoin que de 3
            Le cas Reflexif ET anti-Reflexif à la fois n'est pas possible
            </summary>
        </member>
        <member name="M:Fozzy.Trilean.Prepare">
            <summary>
            Il faut surimposer, arbitrairement sur l'Anti ...
            </summary>
        </member>
        <member name="M:Fozzy._Type.#ctor(System.String)">
            <summary>
            là c'est chaud : Je ne maîtrise pas bien dans quelle Dll il faut chercher le Type
            </summary>
            <param name="type"></param>
        </member>
        <member name="M:Fozzy._Type.Execute(Fozzy.IName,System.String)">
            <summary>
            Here the basic Execution
            </summary>
            <param name="target"></param>
            <param name="method"></param>
        </member>
        <member name="M:Fozzy._Type.Stamp">
            <summary>
            Argh : On devrait faire quelque chose ici ?
            </summary>
        </member>
        <!-- Commentaire XML incorrect ignoré pour le membre "P:Fozzy._Type.Target" -->
        <member name="T:Fozzy.Reader">
            <summary>
            On peut pas fabriquer un reader sans lui passer un fichier ...
            </summary>
        </member>
        <member name="M:Fozzy._Writer.Execute(System.IO.Stream)">
            <summary>
            Argh : ici yavait une récurrence, en lisant par 1024 octets
            Mais en fait je préfère faire en une passe d'un ReadToEnd
            </summary>
            <param name="target"></param>
        </member>
        <member name="T:Fozzy.Identifier">
            <summary>
            Identifier
            </summary>
        </member>
        <member name="T:Fozzy.Member`1">
            <summary>
            Cet Object expose un object pour la Target
            </summary>
            <typeparam name="member"></typeparam>
        </member>
        <member name="M:Fozzy._Properties.Set(System.Object,System.Collections.Generic.IEnumerable{System.String},System.Collections.Generic.IEnumerable{System.Object})">
            <summary>
            Liste synchrone de Names et de Values à setter
            </summary>
            <param name="target"></param>
            <param name="names"></param>
            <param name="values"></param>
        </member>
        <member name="T:Fozzy.Status">
            <summary>
            Une property nécessairement de Type Boolean
            </summary>
        </member>
        <member name="M:Fozzy.Property.Be(Fozzy.Property)">
            <summary>
            Ici ce n'ets pas une égalité de Property qui nous intéresse,
            mais une Egalité de Valeur de Property
            </summary>
            <param name="other"></param>
            <returns></returns>
        </member>
        <!-- Commentaire XML incorrect ignoré pour le membre "M:Fozzy.Property.Get``1(System.Object)" -->
        <member name="M:Fozzy.Property.Load(System.Object,System.Object[])">
            <summary>
            Le Château me passe les 2 paramètres nécessaires à la construction de la Target de la Propriété 
            pour le type Château
            </summary>
            <param name="target"></param>
            <param name="rows"></param>
        </member>
        <member name="M:Fozzy.Property.Set(System.Object,System.Object)">
            <summary>
            Il faut Setter la Propriété avec le contenu de l'Element qui va bien
            Sachant que le node ou attribute à utiliser est défini dans les caractéritiques de Sourcer
            Si la Property Be_Our, on crée une Instance de l'Object en question,
            si Non, on Set directement la property
            Attention, il faut que la Propriété en question est un Set Public
            Noter que si Be_Our, on passe le Name du Type, qui peut servir de Défaut pour retrouver
            </summary>
            <param name="element"></param>
        </member>
        <member name="M:Fozzy.Enumerable.Activates``1(System.Xml.Linq.XElement,System.String)">
            <summary>
            On pourra faire les Activates 
            </summary>
            <typeparam name="Object"></typeparam>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="T:Fozzy.Extension">
            <summary>
            L'extension c'est juste un Name : Donc on n'y prend pas de Directory
            celui-ci est géré à part
            </summary>
        </member>
        <member name="M:Fozzy.NameSpace.#ctor(Fozzy.Property)">
            <summary>
            Initializes a new instance of the Settings class.
            </summary>
        </member>
        <member name="M:Fozzy.Pattern`1.Prepare">
            <summary>
            La construction balaye les Parts fournies au constructeur,
            et les Formate dans un Template, lui aussi reçu au constructeur
            </summary>
        </member>
        <member name="F:Fozzy.Base`1.element">
            <summary>
            Un élément statique utilisé dans l'initialisation
            </summary>
        </member>
        <member name="T:Fozzy.Integer">
            <summary>
            This class groups mathemical operations over 3D vectors
            </summary>
        </member>
        <member name="T:Fozzy.Numeric`1">
            <summary>
            Le Chunk de base Pour les objects system
            Noter que l'on peut ici changer la Value
            </summary>
        </member>
        <member name="M:Fozzy.Numeric`1.Prepare">
            <summary>
            Quand on démarre un Objet de ce Type, on lui affecte les Skills Addition et Multiplication, systématiquement
            </summary>
        </member>
        <member name="T:Fozzy.Single">
            <summary>
            This class groups mathemical operations over 3D vectors
            </summary>
        </member>
        <member name="T:Fozzy.Long">
            <summary>
            This class groups mathemical operations over 3D vectors
            </summary>
        </member>
        <member name="T:Fozzy.Double">
            <summary>
            This class groups mathemical operations over 3D vectors
            </summary>
        </member>
        <member name="M:Fozzy.Pair`1.#ctor(`0)">
            <summary>
            On construit un entity[] parce que sinon ambiguité de constructeur
            </summary>
            <param name="a"></param>
        </member>
        <member name="M:Fozzy.Pair`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Noter que ce 
            </summary>
            <param name="roots"></param>
        </member>
        <member name="T:Fozzy.Manager`1">
            <summary>
            Concept built to manage the FamilyShow Resources conveyed by the ResourceManager
            </summary>
        </member>
        <member name="M:Fozzy.Manager`1.#ctor">
            <summary>
            Chaud ici le doubelusage du Type ...
            </summary>
        </member>
        <member name="M:Fozzy.Verb.Execute(Fozzy.IActionable)">
            <summary>
            Cette Function provoque un déclenchement minimal de Methode
            Avec une référence minimal au Caller, et pas de gestion de Status
            </summary>
        </member>
        <member name="M:Fozzy.Verb.Inform">
            <summary>
            On envoit une Sentence 
            </summary>
        </member>
        <member name="T:Fozzy.Transitive`1">
            <summary>
            Une Skill traitant un Cod
            </summary>
        </member>
        <!-- Commentaire XML incorrect ignoré pour le membre "T:Fozzy.Range`1" -->
        <member name="T:Fozzy.Addition`1">
            <summary>
            This class represent a selection task
            </summary>
        </member>
        <member name="T:Fozzy.Crease`1">
            <summary>
            This class represent a selection task
            </summary>
        </member>
        <member name="T:Fozzy.Multiplication`1">
            <summary>
            This class represent a selection task
            </summary>
        </member>
        <member name="M:Fozzy.Source.#ctor(System.Object,Fozzy.Name)">
            <summary>
            Je ne descends pas la Target ici car elle est confondue avec un Parametre
            </summary>
            <param name="target"></param>
            <param name="name"></param>
        </member>
        <member name="T:Fozzy.Properties.Resources">
            <summary>
              Une classe de ressource fortement typée destinée, entre autres, à la consultation des chaînes localisées.
            </summary>
        </member>
        <member name="P:Fozzy.Properties.Resources.ResourceManager">
            <summary>
              Retourne l'instance ResourceManager mise en cache utilisée par cette classe.
            </summary>
        </member>
        <member name="P:Fozzy.Properties.Resources.Culture">
            <summary>
              Remplace la propriété CurrentUICulture du thread actuel pour toutes
              les recherches de ressources à l'aide de cette classe de ressource fortement typée.
            </summary>
        </member>
        <member name="M:Fozzy.Complement.#ctor(System.Object)">
            <summary>
            Argh : Le object ne va pas au bon endroit 
            </summary>
            <param name="value"></param>
        </member>
        <member name="M:Fozzy.Form.#ctor">
            <summary>
            La Form est défaultée avec un Be 
            </summary>
            <param name="subject"></param>
        </member>
        <member name="T:Fozzy.Be_Test">
            <summary>
            Ne pas chercher à optimiser avec un Boolean
            car l'objet Be est utilisé dès l'Object
            </summary>
        </member>
        <member name="M:Fozzy.Task.Execute">
            <summary>
            Le Execute plante techniquement dans le Try Catch 
            et applicativement ici
            </summary>
        </member>
        <member name="T:Fozzy.XVerb">
            <summary>
            Cet Attribut donne la Signification d'une Classe
            </summary>
        </member>
        <member name="T:Fozzy.XAlias">
            <summary>
            Cet Attribut, indique que la Source est à trouver dans l'Element
            </summary>
        </member>
        <member name="T:Fozzy.XChange">
            <summary>
            Cet Attribut, quand il est présent, déclenche l'event Changed, quand la Property est Set
            </summary>
        </member>
        <member name="T:Fozzy.XDependence">
            <summary>
            Cet Attribut, indique que la Source est à trouver dans l'Element
            </summary>
        </member>
        <member name="M:Fozzy.XDependence.#ctor">
            <summary>
            Quand on ne reçoit pas de Name pour le XSource, on prendra le Type de l'objet sur lequel XSource est implémenté en défaut
            </summary>
        </member>
        <member name="T:Fozzy.XKey">
            <summary>
            Cet Attribut, indique que la Source est à trouver dans l'Element
            </summary>
        </member>
        <member name="M:Fozzy.XKey.#ctor">
            <summary>
            Quand on ne reçoit pas de Name pour le XSource, on prendra le Type de l'objet sur lequel XSource est implémenté en défaut
            </summary>
        </member>
    </members>
</doc>
